shared source/vb/language/shared/refcountedptr.h

   1 //-------------------------------------------------------------------------------------------------
   2 //
   3 //  Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 // Ref Counted Pointer.
   6 //
   7 // Only safe for single threaded operations
   8 //
   9 //-------------------------------------------------------------------------------------------------
  10
  11 #pragma once
  12
  13 template <class T>
  14 class RefCountedPtr
  15 {
  16 private:
  17     struct Data
  18     {
  19         NEW_CTOR_SAFE()
  20
  21         Data() :
  22             pData(NULL),
  23             Count(0)
  24         {
  25         }
  26
  27         ~Data()
  28         {
  29             if ( pData )
  30             {
  31                 delete pData;
  32             }
  33         }
  34
  35         T *pData;
  36         SafeInt<unsigned int> Count;
  37     };
  38
  39 public:
  40
  41     RefCountedPtr()
  42         : m_pData(NULL)
  43     {
  44
  45     }
  46
  47     explicit RefCountedPtr(T* pData)
  48     {
  49         m_pData = new Data();
  50         m_pData->pData = pData;
  51         m_pData->Count = 1;
  52     }
  53
  54     RefCountedPtr(const RefCountedPtr<T> &other)
  55         : m_pData(NULL)
  56     {
  57         // Increment count before assigning the pointer.  Pointer assignment is
  58         // exception safe but incrementing the count is not.  If incrementing the
  59         // count overflows then the count would be N and the number of references
  60         // would be N+1 resulting in a double free.
  61         if ( other.m_pData )
  62         {
  63             other.m_pData->Count +=1;
  64             m_pData = other.m_pData;
  65         }
  66     }
  67
  68     ~RefCountedPtr()
  69     {
  70         Release();
  71     }
  72
  73     operator T*() const
  74     {
  75         return m_pData ? m_pData->pData : NULL;
  76     }
  77
  78     T& operator *() const
  79     {
  80         VSASSERT(m_pData, "Accessing NULL Pointer");
  81         return *(m_pData->pData);
  82     }
  83
  84     T* operator ->()
  85     {
  86         VSASSERT(m_pData, "Accessing NULL Pointer");
  87         return m_pData->pData;
  88     }
  89
  90     const T* operator ->() const
  91     {
  92         VSASSERT(m_pData, "Accessing NULL Pointer");
  93         return m_pData->pData;
  94     }
  95
  96     const RefCountedPtr<T>& operator=(const RefCountedPtr<T>& other)
  97     {
  98         RefCountedPtr<T> temp(other);
  99         TemplateUtil::Swap(&m_pData, &temp.m_pData);
 100         return *this;
 101     }
 102
 103     const RefCountedPtr<T>& operator=(const T& other)
 104     {
 105         RefCountedPtr<T> temp(new T(other));
 106         TemplateUtil::Swap(&m_pData, &temp.m_pData);
 107         return *this;
 108     }
 109
 110     const RefCountedPtr<T>& operator=(T* ptr)
 111     {
 112         RefCountedPtr<T> temp(ptr);
 113         TemplateUtil::Swap(&m_pData, &temp.m_pData);
 114         return *this;
 115     }
 116
 117     void Attach( _In_ T *pData)
 118     {
 119         Release();
 120         RefCountedPtr<T> temp(pData);
 121         *this = temp;
 122     }
 123
 124     void Release()
 125     {
 126         if ( m_pData )
 127         {
 128             VSASSERT(m_pData->Count.Value() != 0, "RefCountedPtr count error");
 129
 130             m_pData->Count -= 1;
 131             if ( 0 == m_pData->Count.Value() )
 132             {
 133                 delete m_pData;
 134             }
 135             m_pData = NULL;
 136         }
 137     }
 138
 139     T* GetData() const
 140     {
 141         return (m_pData) ? m_pData->pData : NULL;
 142     }
 143
 144 private:
 145
 146     void RemoveReference()
 147     {
 148     }
 149
 150     Data* m_pData;
 151 };